package com.ruoyi.verify.controller;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.ruoyi.common.core.domain.R;
import com.ruoyi.verify.domain.VerifyQuestionnaire;
import com.ruoyi.verify.domain.VerifyTemplate;
import com.ruoyi.verify.service.IVerifyTemplateService;
import com.ruoyi.verify.utils.MyUtils;

/**
 * 现场审核模板 提供者
 *
 * @author ygx
 * @date 2020-10-14
 */
@RestController
@RequestMapping("template")
public class VerifyTemplateController extends MyUtils
{

	@Autowired
	private IVerifyTemplateService verifyTemplateService;

	/**
	 * 查询${tableComment}
	 */
	@GetMapping("get/{templateid}")
	public R get(@PathVariable("templateid") String templateid)
	{
		return result(verifyTemplateService.selectVerifyTemplateById(templateid));

	}

	/**
	 * 查询现场审核模板列表
	 */
	@GetMapping("list")
	public R list(VerifyTemplate verifyTemplate)
	{
		startPage();
		List<String> statuslist = verifyTemplate.getStatuslist();
		if (statuslist != null && statuslist.size() > 0) {
			String status = "'" + StringUtils.join(statuslist, "','") + "'";
			verifyTemplate.setStatus(status);
		}
        return result(verifyTemplateService.selectVerifyTemplateList(verifyTemplate));
	}

	/**
	 * 查询现场审核模板列表
	 */
	@GetMapping("templateclasslist")
	public R templateclasslist(String templateid)
	{
		List<VerifyTemplate> verifyTemplate = verifyTemplateService.selectVerifyTemplateClass(templateid);
		return result(verifyTemplate);
	}


	/**
	 * 新增保存现场审核模板
	 */
	@PostMapping("save")
	public Map<String,Object> addSave(@RequestBody VerifyTemplate verifyTemplate)
	{
        Map<String,Object> r = new HashMap<String,Object>();
        Map<String,String> id = new HashMap<String,String>();
    	String result = verifyTemplateService.insertVerifyTemplate(verifyTemplate,"c");
    	if (result.contains("id:"))
    	{
    		id.put("id", result.replace("id:", ""));
        	r.put("code", 0);
    		r.put("msg", "success");
    		r.put("rows", id);
    		return r;
    	}
    	else
    	{
        	r.put("code", 500);
    		r.put("msg", result);
    		return r;
    	}
	}

	/**
	 * 修改保存现场审核模板
	 */
	@PostMapping("update")
	public Map<String, String> editSave(@RequestBody VerifyTemplate verifyTemplate)
	{
		return jacResultMsg(verifyTemplateService.updateVerifyTemplate(verifyTemplate));
	}

	/**
	 * 修改保存现场审核模板状态
	 */
	@PostMapping("updateStatus")
	public Map<String, String> updateStatus(@RequestBody Map<String, List<VerifyTemplate>> datas)
	{
		return jacResultMsg(verifyTemplateService.updateTemplateStatus(datas));
	}

	/**
	 * 删除${tableComment}
	 */
	@PostMapping("remove")
	public Map<String, String> remove(String ids)
	{
		return jacResultMsg(verifyTemplateService.deleteVerifyTemplateByIds(ids));
	}

    /**
     * 获取全部的模板类型
     * @return
     */
	@GetMapping("type")
    public R  getType()
	{
	 return result(verifyTemplateService.selectType());
	}

	/**
	 * 通过模板id获取该模板所有模块的名称和id
	 */
	@GetMapping("getVerifyid/{templateid}")
	public R getVerifyid(@PathVariable("templateid") String templateid)
	{
		return result(verifyTemplateService.selectVerifyid(templateid));

	}

	/**
	 * 通过模板id获取该模板所有模块的名称和id
	 */
	@GetMapping("getverifyclass/{verifytype}/{factorycode}")
	public R getVerifyid(@PathVariable("verifytype") String verifytype,@PathVariable("factorycode") String factorycode)
	{
		List<VerifyTemplate> verifyTemplates = verifyTemplateService.selectVerifyTemplateClassNew(verifytype, factorycode);
		if(verifytype.contains("VDA6.3")){//VDA6.3中，P6的子模块不显示
			verifyTemplates = verifyTemplates.stream().filter(v -> !v.getContent().startsWith("6.")).collect(Collectors.toList());
		}
		return result(verifyTemplates);

	}

	/**
	 * 根据计划id、公司（废弃）、供应商代码生成问卷
	 */
	@PostMapping("insertQuestionnaire")
	public Map<String,String> insertQuestionnaire(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	{
		return jacResultMsg(verifyTemplateService.insertQuestionnaire(verifyQuestionnaire,""));

	}



    /**
     * 通过计划的计划id，供应商编码,用户id（后台获取参数）获取审核问卷
     *
     * @param VerifyQuestionnaire
     * @return 结果
     */
	@PostMapping("getQuestionnaire")
	public Map<String,Object> getQuestionnaire(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	{
		return result(verifyTemplateService.selectQuestionnaire(verifyQuestionnaire));
	}

	/**
	 * VDA审核完成后，预览整个试卷查看结果。
	 */
	@PostMapping("getVdaQuestionnaireFinally")
	public Map<String,Object> getVdaQuestionnaireFinally(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	{
		return result(verifyTemplateService.selectAllQuestionnaire(verifyQuestionnaire));
	}

	/**
	 * 审核完成后，预览整个试卷查看结果。
	 */
	@PostMapping("getQuestionnaireFinally")
	public Map<String,Object> getQuestionnaireFinally(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	{
		return result(verifyTemplateService.selectAllQuestionnaire(verifyQuestionnaire));
	}

    /**
     * 根据模板id预览审核问卷
     *
     * @param VerifyQuestionnaire
     * @return 结果
     */
	@GetMapping("getQuestionnaire/{templateid}/{verifytype}")
	public Map<String,Object> getQuestionnaire(@PathVariable("templateid") String templateid,@PathVariable("verifytype") String verifytype)
	{
		return result(verifyTemplateService.selectQuestionnaire(templateid,verifytype));
	}

	   /**
     * 根据问卷id更新问卷打分、打分人、备注
     * @param verifyTemplateContent
     * @return
     */
	@PostMapping("updateQuestionnaire")
    public Map<String,String> updateQuestionnaire(@RequestBody Map<String, List<VerifyQuestionnaire>> datas)
    {
    	return jacResultMsg(verifyTemplateService.updateQuestionnaire(datas));
    }

 	/**
 	 * 提交问卷
 	 * @param 计划id：planid
 	 * @param 供应商code ：vendorcode
 	 * @param
 	 * @return 结果
 	 */
	 @PostMapping("commitQuestionnaire")
     public Map<String,String> commitQuestionnaire(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	 {
		 return jacResultMsg(verifyTemplateService.commitQuestionnaire(verifyQuestionnaire));
	 }

	/**
	  * 根据计划id和供应商code获取问卷结果
	  * @param planid vendorcode
	  * @return
	  */
	 @PostMapping("getResult")
     public R getResult(@RequestBody VerifyQuestionnaire verifyQuestionnaire)
	 {
		 if(verifyQuestionnaire.getVerifytype().contains("VDA6.3")){
			 return jacResultLinkedMap(verifyTemplateService.selectVdaResult(verifyQuestionnaire));
		 }
		 return jacResultLinkedMap(verifyTemplateService.selectResult(verifyQuestionnaire));
	 }

}
